const https = require('https');// 
const SQLHelper = require('./SQLHelper');
const { formatTime } = require('./util')
///雪花算法生成ID
const snowflake = require('./snowflake')

const multer = require('multer')

const storage = multer.diskStorage({
    destination: './uploads',
    filename: function (req, file, cb) {
        ///获取图片类型
    
        let fileType = file.originalname.split('.')
        fileType = fileType[fileType.length - 1]
        cb(null, snowflake() + '.' + fileType)
        console.log(file)
    }
})

const upload = multer({ storage: storage })

module.exports = function (app) {
    //登录拦截中间件
    function loginRouter(req, res, next) {
        if (req.method.toUpperCase() == 'OPTIONS') {
            next()
            return;
        }
        let token = req.headers.token
        // console.log(token)
        if (token) {
            SQLHelper(`select * from session where id = ${token} and state = 1`).then(ret => {
                if (ret.length) {
                    let session = ret[0]
                    ///2H
                    // console.log(ret)
                    if (new Date().getTime() - session.createTime < 2 * 60 * 60 * 1000) {
                        req.session = {
                            userId: session.userId,
                            userName: session.userName
                        }
                        next()
                    } else {
                        res.status(400).send({ errorMsg: '登录超时' })
                    }
                } else {
                    res.status(400).send({ errorMsg: '当前用户未登录' })
                }
            })
        } else {
            res.status(400).send({ errorMsg: '缺少token,请先进行登录' })
        }
    }
    ///让初登录以外的所有小程序接口都要先验证登录
    app.use('/admin', loginRouter)

    ///图片上传
    app.post('/upload', upload.single('file'), (req, res) => {
        res.send(req.file)
    })



    ////管理员后台登陆
    app.post('/login', (req, res) => {
        let userName = req.body.userName
        let passWord = req.body.passWord
        if (userName && passWord) {
            SQLHelper(`
            select * from user where userName = '${userName}'
        `).then(users => {
                if (users.length) {///正常登录
                    let user = users[0]
                    if (passWord == user.passWord) {
                        let token = snowflake()
                        //缓存到token到session表
                        SQLHelper(`
                    INSERT INTO session(id,userId,userName,inTime,createTime,platform) 
                    VALUES ('${token}','${user._id}','${user.nickName}','${formatTime(new Date())}','${new Date().getTime()}','admin')
                    `).then(ret => {
                            res.send({
                                nickName: user.nickName,
                                token,
                                avatarUrl: user.photo,
                                _id: user._id
                            })
                        })
                    } else {
                        res.send({ errorMsg: '密码出错' })
                    }
                } else {
                    res.send({ errorMsg: '当前用户不存在' })
                }
            })
        } else {
            res.send({ errorMsg: '用户名和密码不能为空' })
        }
    })
    ///退出登录
    app.get('/admin/logout', (req, res) => {
        SQLHelper(`
    UPDATE session set outTime = '${formatTime(new Date())}',state = 0
    WHERE id = '${req.headers.token}'
    `).then(ret => {
            res.send({ msg: '退出登录成功' })
        })
    })

    //修改密码
    app.post('/admin/changePassWord', (req, res) => {
        let userId = req.session.userId
        let passWord = req.body.passWord
        let newPassWord = req.body.newPassWord
        if (passWord && newPassWord) {
            ///通过userId查询用户
            SQLHelper(`
        select passWord from user where _id = '${userId}'`).then(users => {
                let user = users[0]
                //比对原密码
                if (user.passWord == passWord) {
                    //修改密码
                    SQLHelper(`update user set passWord = '${newPassWord}' where _id  = '${userId}' `).then(ret => {
                        res.send({ msg: '修改密码成功' })
                    })
                } else {
                    res.send({ errorMsg: '原密码错误' })
                }
            })
        } else (
            res.send({ errorMsg: '原密码和新密码不能为空' })
        )
    })

    ///分页获取首页项目列表
    ///pageSize 每页大小 默认10 
    /// pageNum 当前页 默认1
    ///type 类型 非必填 banner,轮播图 category,分类 recommend,为了推荐 不填搜索全部
    app.get('/admin/index', (req, res) => {
        let pageSize = req.query.pageSize || 10
        let pageNum = req.query.pageNum || 1
        let offset = (pageNum - 1) * pageSize
        let title = req.query.title
        let type = req.query.type
        let whereSql = `from index_region where state = 1`
        ///按类型查询
        if (type) whereSql += ` and type = '${type}'`
        ///按标题关键字搜索
        if (title) whereSql += ` and title like "%${title}%"`
        SQLHelper(`
        select count(*) as total ${whereSql};
        select * ${whereSql}
        limit ${pageSize} offset ${offset}
    `).then(ret => {
            res.send({
                total: ret[0][0].total,
                rows: ret[1]
            })
        })
    })

    ///新增轮播图
    //img 图片地址 必填
    /// url 连接地址 非必填
    /// status 是否启用 非必填 1启用 0停用
    ///type 类型 非必填 banner(默认)，轮播图，category,分类，recommend,为你推荐
    app.post('/admin/index', (req, res) => {
        let img = req.body.img, url = req.body.url, status = req.body.status
        let type = req.body.type || 'banner', title = req.body.title
        if (type != 'banner' && !title) {
            res.send({ errorMsg: '标题不能为空' })
            return
        }
        if (status != 1) status = 0//默认启用
        if (img) {
            let createTime = new Date().getTime()
            SQLHelper(`
        INSERT INTO index_region(title,img,url,status,state,createTime,unitId,type)
        VALUES ('banner','${img}','${url}','${status}',1,'${createTime}','juzao','${type}')
        `).then(ret => {
                res.send(ret.insertId ? { _id: ret.insertId } : { errorMsg: "新增数据失败" })
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

    //修改首页项目
    ///index  主码_id 必填

    app.put('/admin/index', (req, res) => {
        if (req.body.indexId) {
            //需要修改的项
            let updateKey = ['img', 'url', 'title', 'status']
            let updateValues = []
            for (let i = 0; i < updateKey.length; i++) {
                let key = updateKey[i], value = req.body[key]
                if (value) updateValues.push(`${key} = '${value}'`)  ///判断哪些需要修改
            }
            SQLHelper(`update index_region set ${updateValues.join(',')} where _id = ${req.body.indexId}`).then(ret => {
                res.send(ret)
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

    //删除首页项目  逻辑删除
    ///indexId 主码_id 必填
    app.delete('/admin/index', (req, res) => {
        let indexId = req.query.indexId
        if (indexId) {
            SQLHelper(`
                UPDATE index_region
                set state = 0
                WHERE _id = ${indexId}
                `).then(ret => {
                res.send(ret)
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })


///新闻
      ///分页获取新闻项目列表
    ///pageSize 每页大小 默认10 
    /// pageNum 当前页 默认1
    ///type 类型 非必填 
    app.get('/admin/index/news', (req, res) => {
        let pageSize = req.query.pageSize || 10
        let pageNum = req.query.pageNum || 1
        let offset = (pageNum - 1) * pageSize
        let title = req.query.title
        let type = req.query.type
        let whereSql = `from article where state = 1`
        ///按类型查询
        if (type) whereSql += ` and type = '${type}'`
        ///按标题关键字搜索
        if (title) whereSql += ` and title like "%${title}%"`
        SQLHelper(`
        select count(*) as total ${whereSql};
        select * ${whereSql}
        limit ${pageSize} offset ${offset}
    `).then(ret => {
            res.send({
                total: ret[0][0].total,
                rows: ret[1]
            })
        })
    })
    

     ///新增新闻
    //img 图片地址 
    /// title  必填
    /// status 是否启用 非必填 1启用 0停用
     /// hot 是否启用 非必填 1启用 0停用
    ///type 类型 非必填 news(默认)
    app.post('/admin/index/news', (req, res) => {
        let img = req.body.img,digest = req.body.digest, status = req.body.status
        let type = req.body.type || 'news', title = req.body.title,hot = req.body.hot
        if (type != 'news' && !title) {
            res.send({ errorMsg: '标题不能为空' })
            return
        }
        if (status != 1) status = 0//默认启用
        if (hot != 0) hot = 1 //默认启用
        if (title) {
            let createTime = new Date().getTime()
            SQLHelper(`
        INSERT INTO article(title,img,digest,status,hot,state,createTime,unitId,type)
        VALUES ('${title}','${img}','${digest}','${status}','${hot}',1,'${createTime}','juzao','news')
        `).then(ret => {
                res.send(ret.insertId ? { _id: ret.insertId } : { errorMsg: "新增数据失败" })
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

      //删除新闻  逻辑删除
    ///indexId 主码_id 必填
    app.delete('/admin/index/news', (req, res) => {
        let indexId = req.query.indexId
        if (indexId) {
            SQLHelper(`
                UPDATE article
                set state = 0
                WHERE _id = ${indexId}
                `).then(ret => {
                res.send(ret)
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

        //修改新闻项目
    ///index  主码_id 必填

    app.put('/admin/index/news', (req, res) => {
        if (req.body.indexId) {
            //需要修改的项
            let updateKey = ['img','title','digest', 'status','hot']
            let updateValues = []
            for (let i = 0; i < updateKey.length; i++) {
                let key = updateKey[i], value = req.body[key]
                if (value) updateValues.push(`${key} = '${value}'`)  ///判断哪些需要修改
            }
            SQLHelper(`update article set ${updateValues.join(',')} where _id = ${req.body.indexId}`).then(ret => {
                res.send(ret)
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

///品牌
      ///分页获品牌项目列表
    ///pageSize 每页大小 默认10 
    /// pageNum 当前页 默认1
    ///type 类型 非必填 
    app.get('/admin/index/brand', (req, res) => {
        let pageSize = req.query.pageSize || 10
        let pageNum = req.query.pageNum || 1
        let offset = (pageNum - 1) * pageSize
        let name = req.query.name
        let whereSql = `from brand where state = 1`
        ///按标题关键字搜索
        if (name) whereSql += ` and name like "%${name}%"`
        SQLHelper(`
        select count(*) as total ${whereSql};
        select * ${whereSql}
        limit ${pageSize} offset ${offset}
    `).then(ret => {
            res.send({
                total: ret[0][0].total,
                rows: ret[1]
            })
        })
    })
    

     ///新增品牌
    //img 图片地址 
    /// name  必填
    app.post('/admin/index/brand', (req, res) => {
        let img = req.body.img, sort = req.body.sort
        let  name = req.body.name
        if ( !name) {
            res.send({ errorMsg: '品牌名称不能为空' })
            return
        }
       
        if (name) {
            let createTime = new Date().getTime()
            SQLHelper(`
        INSERT INTO brand(name,img,sort,state,createTime,unitId)
        VALUES ('${name}','${img}','${sort}',1,'${createTime}','juzao')
        `).then(ret => {
                res.send(ret.insertId ? { _id: ret.insertId } : { errorMsg: "新增数据失败" })
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

      //删除品牌  逻辑删除
    ///indexId 主码_id 必填
    app.delete('/admin/index/brand', (req, res) => {
        let indexId = req.query.indexId
        if (indexId) {
            SQLHelper(`
                UPDATE brand
                set state = 0
                WHERE _id = ${indexId}
                `).then(ret => {
                res.send(ret)
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

        //修改品牌项目
    ///index  主码_id 必填

    app.put('/admin/index/brand', (req, res) => {
        if (req.body.indexId) {
            //需要修改的项
            let updateKey = ['img','name','sort']
            let updateValues = []
            for (let i = 0; i < updateKey.length; i++) {
                let key = updateKey[i], value = req.body[key]
                if (value) updateValues.push(`${key} = '${value}'`)  ///判断哪些需要修改
            }
            SQLHelper(`update brand set ${updateValues.join(',')} where _id = ${req.body.indexId}`).then(ret => {
                res.send(ret)
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

///商品
      ///分页获取商品项目列表
    ///pageSize 每页大小 默认10 
    /// pageNum 当前页 默认1
    ///type 类型 非必填 
    app.get('/admin/index/product', (req, res) => {
        let pageSize = req.query.pageSize || 10
        let pageNum = req.query.pageNum || 1
        let offset = (pageNum - 1) * pageSize
        let name = req.query.name
        let whereSql = `from product where state = 1`
        ///按标题关键字搜索
        if (name) whereSql += ` and title like "%${name}%"`
        SQLHelper(`
        select count(*) as total ${whereSql};
        select * ${whereSql}
        limit ${pageSize} offset ${offset}
    `).then(ret => {
            res.send({
                total: ret[0][0].total,
                rows: ret[1]
            })
        })
    })
    

     ///新增商品
    //img 图片地址 
    /// name  必填
    app.post('/admin/index/product', (req, res) => {
        let imgs = req.body.imgs, sales = req.body.sales, brandId = req.body.brandId
        let  name = req.body.name,status = req.body.status
        if(!imgs){
            res.send({errorMsg:"轮播图不能为空"})
        }
        if(!name){
            res.send({errorMsg:"名称不能为空"})
        }
        if(!brandId){
            res.send({errorMsg:"品牌不能为空"})
        }
        if (status != 1) status = 1 ///默认启用
        if (name && imgs && brandId) {
            let createTime = new Date().getTime()
            SQLHelper(`
        INSERT INTO product(name,imgs,sales,state,brandId,createTime,unitId)
        VALUES ('${name}','${imgs}','${sales}',1,'${brandId}','${createTime}','juzao')
        `).then(ret => {
                res.send(ret.insertId ? { _id: ret.insertId } : { errorMsg: "新增数据失败" })
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

      //删除商品  逻辑删除
    ///indexId 主码_id 必填
    app.delete('/admin/index/product', (req, res) => {
        let indexId = req.query.indexId
        if (indexId) {
            SQLHelper(`
                UPDATE product
                set state = 0
                WHERE _id = ${indexId}
                `).then(ret => {
                res.send(ret)
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

        //修改商品项目
    ///index  主码_id 必填

    app.put('/admin/index/product', (req, res) => {
        if (req.body.indexId) {
            //需要修改的项
            let updateKey = ['imgs', 'name', 'brandId','sales', 'status']
            let updateValues = []
            for (let i = 0; i < updateKey.length; i++) {
                let key = updateKey[i], value = req.body[key]
                if (value) updateValues.push(`${key} = '${value}'`)  ///判断哪些需要修改
            }
            SQLHelper(`update product set ${updateValues.join(',')} where _id = ${req.body.indexId}`).then(ret => {
                res.send(ret)
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })

    //********************************
    //单品
    ///获取单品项目
    ///pageSize每页大小 默认10 
    // pageNum   当前页  默认1
    //name 为模糊查询关键字
    app.get('/admin/index/sku', (req, res) => {
        let pageSize = req.query.pageSize || 10
        let pageNum = req.query.pageNum || 1
        let offset = (pageNum - 1) * pageSize
        let name = req.query.name
        let whereSql = 'from sku where state = 1'
        //按标题关键字搜索
        if (name) whereSql += ` and (skuId like "%${name}%" or productName like "%${name}%" or props like "%${name}%")`
        SQLHelper(`select count(*) as total  ${whereSql} ;
        select * ${whereSql} limit ${pageSize} offset ${offset}
        `).then(ret => {
            res.send({
                total: ret[0][0].total,
                rows: ret[1]
            })
        })
    })
    //增加单品项目  
    //imgs 图片 productname  商品名称 skuID必填
    app.post('/admin/index/sku', (req, res) => {
        let imgs = req.body.imgs,skuId = req.body.skuId,salePrice = req.body.salePrice,originalPrice = req.body.originalPrice
        let props = req.body.props,productName =req.body.productName,productId = req.body.productId
        if (!imgs && !productName && !skuId) {
            res.send({ errorMsg: "图片,商品名称,skuid不能为空" })
            return
        }
        if (imgs && productName && skuId) {
            let createTime = new Date().getDate()
            SQLHelper(`
            INSERT INTO sku(skuId,salePrice,originalPrice,productId,productName,imgs,props,createTime,state,unitId) 
            VALUES('${skuId}','${salePrice}','${originalPrice}','${productId}','${productName}','${imgs}','${props}','${createTime}','1','juzao')
            `).then(ret => {
                res.send(ret.insertId ? { _id: ret.insertId } : { errorMsg: "新增数据失败" })
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })
    ///修改单品项目
    ///indexId  _id 必填
    app.put('/admin/index/sku', (req, res) => {
        if (req.body.indexId) {
            ///需要修改的项
            let updateTime = new Date().getTime()
            let updateKey = ['skuId', 'salePrice', 'originalPrice', 'productId', 'productName','imgs','props']
            let updateValues = [`updateTime = ${updateTime}`]
            for (let i = 0; i < updateKey.length; i++) {
                let key = updateKey[i], value = req.body[key]
                if (value !== undefined) updateValues.push(`${key}='${value}'`)///判断哪些项需要修改
            }
            SQLHelper(`UPDATE sku set ${updateValues.join(',')} WHERE _id = ${req.body.indexId}`).then(ret => {
                res.send(ret)
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })
    //商品删除接口 单个删除
    app.delete('/admin/index/sku', (req, res) => {
        let indexId = req.query.indexId
        if (indexId) {
            SQLHelper(`
            UPDATE sku
            set state = 0 
            WHERE _id = ${indexId}
            `).then(ret => {
                res.send(ret)
            })
        } else {
            res.send({ errorMsg: '传入参数错误' })
        }
    })
    //检验唯一id
    app.put("/admin/index/checkId",(req,res)=>{
        let skuId = req.body.skuId
        SQLHelper(`select *from sku where skuId = '${skuId}'`).then(ret=>{
            if(ret ==false){
                res.send(true)
            }
            else{
                res.send(false)
            }
        })
    })
    
}
